/* 
 *  Incub - incubate your baby robot
 *  Copyright (C) 2008 Stanislaw Szymczyk
 *  e-mail: sszymczy@gmail.com   www: http://cogville.cog-lab.com
 *
 *  This file is part of Incub.
 *
 *  Incub is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Incub is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Incub.  If not, see <http://www.gnu.org/licenses/>.
 * 
 */
 
#ifndef CORBAIMPLEMENTATIONS_H_
#define CORBAIMPLEMENTATIONS_H_

#include "incub.hh"

class VShapeOut_i : public virtual OBV_VShapeOut, public virtual CORBA::DefaultValueRefCountBase {
};

class VShapeOutFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VShapeOut_i();
	}
};

class VSensorOut_i : public virtual OBV_VSensorOut, public virtual CORBA::DefaultValueRefCountBase {
};

class VSensorOutFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VSensorOut_i();
	}
};

class VAngularVelocimeterOut_i : public virtual OBV_VAngularVelocimeterOut, public virtual CORBA::DefaultValueRefCountBase {
	public:
	VAngularVelocimeterOut_i() : OBV_VSensorOut() {
	};
	VAngularVelocimeterOut_i(double x, double y, double z) : OBV_VSensorOut(), OBV_VAngularVelocimeterOut(x, y, z) {
	};
};

class VAngularVelocimeterOutFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VAngularVelocimeterOut_i();
	}
};

class VLinearVelocimeterOut_i : public virtual OBV_VLinearVelocimeterOut, public virtual CORBA::DefaultValueRefCountBase {
	public:
	VLinearVelocimeterOut_i() : OBV_VSensorOut() {
	};
	VLinearVelocimeterOut_i(double x, double y, double z) : OBV_VSensorOut(), OBV_VLinearVelocimeterOut(x, y, z) {
	};
};

class VLinearVelocimeterOutFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VLinearVelocimeterOut_i();
	}
};

class VPositionSensorOut_i : public virtual OBV_VPositionSensorOut, public virtual CORBA::DefaultValueRefCountBase {
	public:
	VPositionSensorOut_i() : OBV_VSensorOut() {
	};
	VPositionSensorOut_i(double x, double y, double z) : OBV_VSensorOut(), OBV_VPositionSensorOut(x, y, z) {
	};
};

class VPositionSensorOutFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VPositionSensorOut_i();
	}
};

class VTactileMatrixOut_i : public virtual OBV_VTactileMatrixOut, public virtual CORBA::DefaultValueRefCountBase {
	public:
	VTactileMatrixOut_i() : OBV_VSensorOut() {
	};
	VTactileMatrixOut_i(VTactileSensorsOut *sensors) : OBV_VSensorOut(), OBV_VTactileMatrixOut(sensors) {
	};
};

class VTactileMatrixOutFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VTactileMatrixOut_i();
	}
};

class VTactileSensorOut_i : public virtual OBV_VTactileSensorOut, public virtual CORBA::DefaultValueRefCountBase {
	public:
	VTactileSensorOut_i() {
	};
	VTactileSensorOut_i(double x, double y, double z, double activation) : OBV_VTactileSensorOut(x, y, z, activation) {
	};
};

class VTactileSensorOutFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VTactileSensorOut_i();
	}
};

class VJointOut_i : public virtual OBV_VJointOut, public virtual CORBA::DefaultValueRefCountBase {
	public:
	VJointOut_i() {
	}
	VJointOut_i(VEntityOut *entity, VMotorsOut *motors) : OBV_VJointOut(entity, motors) {
	}
};

class VJointOutFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VJointOut_i();
	}
};

class VJointIn_i : public virtual OBV_VJointIn, public virtual CORBA::DefaultValueRefCountBase {
	public:
	VJointIn_i() {
	}
	VJointIn_i(VEntityIn *entity, VMotorsIn *motors) : OBV_VJointIn(entity, motors) {
	}
};

class VJointInFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VJointIn_i();
	}
};

class VWorldOut_i : public virtual OBV_VWorldOut, public virtual CORBA::DefaultValueRefCountBase {
	public:
	VWorldOut_i() {
	}
	VWorldOut_i(VEntitiesOut *entities) : OBV_VWorldOut(entities) {
	}
};

class VWorldOutFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VWorldOut_i();
	}
};

class VWorldIn_i : public virtual OBV_VWorldIn, public virtual CORBA::DefaultValueRefCountBase {
	public:
	VWorldIn_i() {
	}
	VWorldIn_i(VEntitiesIn *entities) : OBV_VWorldIn(entities) {
	}
};

class VWorldInFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VWorldIn_i();
	}
};

class VEntityOut_i : public virtual OBV_VEntityOut, public virtual CORBA::DefaultValueRefCountBase {
	public:
	VEntityOut_i() {
	}
	VEntityOut_i(VJointsOut *joints, VShapesOut *shapes, VSensorsOut *sensors) : OBV_VEntityOut(joints, shapes, sensors) {
	}
};

class VEntityOutFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VEntityOut_i();
	}
};

class VEntityIn_i : public virtual OBV_VEntityIn, public virtual CORBA::DefaultValueRefCountBase {
	public:
	VEntityIn_i() {
	}
	VEntityIn_i(VJointsIn *joints) : OBV_VEntityIn(joints) {
	}
};

class VEntityInFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VEntityIn_i();
	}
};

class VCameraOut_i : public virtual OBV_VCameraOut, public virtual CORBA::DefaultValueRefCountBase {
	public:
	VCameraOut_i() {
	}
	VCameraOut_i(long width, long height, long depth, VImageOut* image) : OBV_VSensorOut(), OBV_VCameraOut(width, height, depth, image) {
	}
};

class VCameraOutFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VCameraOut_i();
	}
};

class VMotorOut_i : public virtual OBV_VMotorOut, public virtual CORBA::DefaultValueRefCountBase {
	public:
	VMotorOut_i() {
	}
	VMotorOut_i(float angle, float loStop, float hiStop) : OBV_VMotorOut(angle, loStop, hiStop) {
	}
};

class VMotorOutFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VMotorOut_i();
	}
};

class VVelocityControlledMotorOut_i : public virtual OBV_VVelocityControlledMotorOut, public virtual CORBA::DefaultValueRefCountBase {
	public:
	VVelocityControlledMotorOut_i() : OBV_VMotorOut() {
	}
	VVelocityControlledMotorOut_i(float angle, float loStop, float hiStop, float desiredVelocity, float maxForce) : OBV_VMotorOut(), OBV_VVelocityControlledMotorOut(angle, loStop, hiStop, desiredVelocity, maxForce) {
	}	
};

class VVelocityControlledMotorOutFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VVelocityControlledMotorOut_i();
	}
};

class VTorqueControlledMotorOut_i : public virtual OBV_VTorqueControlledMotorOut, public virtual CORBA::DefaultValueRefCountBase {
	public:
	VTorqueControlledMotorOut_i() : OBV_VMotorOut() {
	}
	VTorqueControlledMotorOut_i(float angle, float loStop, float hiStop, float torque) : OBV_VMotorOut(), OBV_VTorqueControlledMotorOut(angle, loStop, hiStop, torque) {
	}
};

class VTorqueControlledMotorOutFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VTorqueControlledMotorOut_i();
	}
};

class VMotorIn_i : public virtual OBV_VMotorIn, public virtual CORBA::DefaultValueRefCountBase {
	public:
	VMotorIn_i() {
	}
};

class VMotorInFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VMotorIn_i();
	}
};

class VVelocityControlledMotorIn_i : public virtual OBV_VVelocityControlledMotorIn, public virtual CORBA::DefaultValueRefCountBase {
	public:
	VVelocityControlledMotorIn_i() : OBV_VMotorIn() {
	}
	VVelocityControlledMotorIn_i(float desiredVelocity, float maxForce) : OBV_VMotorIn(), OBV_VVelocityControlledMotorIn(desiredVelocity, maxForce) {
	}
};

class VVelocityControlledMotorInFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VVelocityControlledMotorIn_i();
	}
};

class VTorqueControlledMotorIn_i : public virtual OBV_VTorqueControlledMotorIn, public virtual CORBA::DefaultValueRefCountBase {
	public:
	VTorqueControlledMotorIn_i() : OBV_VMotorIn() {
	}
	VTorqueControlledMotorIn_i(float torque) : OBV_VMotorIn(), OBV_VTorqueControlledMotorIn(torque) {
	}
};

class VTorqueControlledMotorInFactory : public virtual CORBA::ValueFactoryBase {
	CORBA::ValueBase* create_for_unmarshal() {
		return new VTorqueControlledMotorIn_i();
	}
};

#endif /*CORBAIMPLEMENTATIONS_H_*/
